home *** CD-ROM | disk | FTP | other *** search
/ Champak 66 / Vol 66.iso / games / daphne.swf / scripts / __Packages / MochiAd.as
Text File  |  2013-04-24  |  32KB  |  841 lines
  1. function ┬º\x04\x05┬º()
  2. {
  3.    set("\x03",2791 % 511 * 5);
  4.    return eval("\x03");
  5. }
  6. var ┬º\x01┬º = -195 + "\x04\x05"();
  7. while(true)
  8. {
  9.    if(eval("\x01") == 985)
  10.    {
  11.       set("\x01",eval("\x01") - 17);
  12.       ┬º┬ºpush(true);
  13.    }
  14.    else if(eval("\x01") == 825)
  15.    {
  16.       set("\x01",eval("\x01") + 145);
  17.       ┬º┬ºpush(true);
  18.    }
  19.    else if(eval("\x01") == 156)
  20.    {
  21.       set("\x01",eval("\x01") + 445);
  22.    }
  23.    else if(eval("\x01") == 216)
  24.    {
  25.       set("\x01",eval("\x01") - 10);
  26.       if(function ┬º\x04\x05┬º()
  27.       {
  28.          set("\x03",2791 % 511 * 5);
  29.          return eval("\x03");
  30.       })
  31.       {
  32.          set("\x01",eval("\x01") + 776);
  33.       }
  34.    }
  35.    else if(eval("\x01") == 956)
  36.    {
  37.       set("\x01",eval("\x01") - 612);
  38.    }
  39.    else if(eval("\x01") == 27)
  40.    {
  41.       set("\x01",eval("\x01") + 676);
  42.       var ┬º┬ºpop() = function ┬º\x04\x05┬º()
  43.       {
  44.          set("\x03",2791 % 511 * 5);
  45.          return eval("\x03");
  46.       };
  47.    }
  48.    else if(eval("\x01") == 982)
  49.    {
  50.       set("\x01",eval("\x01") - 638);
  51.    }
  52.    else if(eval("\x01") == 828)
  53.    {
  54.       set("\x01",eval("\x01") - 481);
  55.    }
  56.    else
  57.    {
  58.       if(eval("\x01") == 192)
  59.       {
  60.          set("\x01",eval("\x01") + 293);
  61.          function ┬º\x04\x05┬º()
  62.          {
  63.             set("\x03",2791 % 511 * 5);
  64.             return eval("\x03");
  65.          }.allowDomain();
  66.          System.security.allowDomain(_loc1_);
  67.          if(System.security.allowInsecureDomain)
  68.          {
  69.             System.security.allowInsecureDomain("*");
  70.             System.security.allowInsecureDomain(_loc1_);
  71.          }
  72.          return _loc1_;
  73.       }
  74.       if(eval("\x01") == 832)
  75.       {
  76.          set("\x01",eval("\x01") - 231);
  77.       }
  78.       else if(eval("\x01") == 968)
  79.       {
  80.          set("\x01",eval("\x01") - 776);
  81.          if(function ┬º\x04\x05┬º()
  82.          {
  83.             set("\x03",2791 % 511 * 5);
  84.             return eval("\x03");
  85.          })
  86.          {
  87.             set("\x01",eval("\x01") + 293);
  88.          }
  89.       }
  90.       else
  91.       {
  92.          if(eval("\x01") == 347)
  93.          {
  94.             set("\x01",eval("\x01") + 501);
  95.             if(!_global.MochiAd)
  96.             {
  97.                var _loc2_ = _global.MochiAd = function()
  98.                {
  99.                }.prototype;
  100.                _global.MochiAd = function()
  101.                {
  102.                }.getVersion = function()
  103.                {
  104.                   return "2.2";
  105.                };
  106.                _global.MochiAd = function()
  107.                {
  108.                }.showPreGameAd = function(options)
  109.                {
  110.                   var _loc27_ = {clip:_root,ad_timeout:3000,fadeout_time:250,regpt:"o",method:"showPreloaderAd",color:16747008,background:16777161,outline:13994812,ad_started:function()
  111.                   {
  112.                      this.clip.stop();
  113.                   },ad_finished:function()
  114.                   {
  115.                      this.clip.play();
  116.                   }};
  117.                   options = MochiAd._parseOptions(options,_loc27_);
  118.                   var clip = options.clip;
  119.                   var _loc23_ = 11000;
  120.                   var _loc26_ = options.ad_timeout;
  121.                   delete options.ad_timeout;
  122.                   var fadeout_time = options.fadeout_time;
  123.                   delete options.fadeout_time;
  124.                   if(!MochiAd.load(options))
  125.                   {
  126.                      options.ad_finished();
  127.                      return undefined;
  128.                   }
  129.                   options.ad_started();
  130.                   var mc = clip._mochiad;
  131.                   mc.onUnload = function()
  132.                   {
  133.                      options.ad_finished();
  134.                   };
  135.                   var _loc14_ = MochiAd._getRes(options);
  136.                   var _loc4_ = _loc14_[0];
  137.                   var _loc13_ = _loc14_[1];
  138.                   mc._x = _loc4_ * 0.5;
  139.                   mc._y = _loc13_ * 0.5;
  140.                   var chk = mc.createEmptyMovieClip("_mochiad_wait",3);
  141.                   chk._x = _loc4_ * -0.5;
  142.                   chk._y = _loc13_ * -0.5;
  143.                   var _loc7_ = chk.createEmptyMovieClip("_mochiad_bar",4);
  144.                   _loc7_._x = 10;
  145.                   _loc7_._y = _loc13_ - 20;
  146.                   var _loc22_ = options.color;
  147.                   delete options.color;
  148.                   var _loc19_ = options.background;
  149.                   delete options.background;
  150.                   var _loc24_ = options.outline;
  151.                   delete options.outline;
  152.                   var _loc5_ = _loc7_.createEmptyMovieClip("_outline",1);
  153.                   _loc5_.beginFill(_loc19_);
  154.                   _loc5_.moveTo(0,0);
  155.                   _loc5_.lineTo(_loc4_ - 20,0);
  156.                   _loc5_.lineTo(_loc4_ - 20,10);
  157.                   _loc5_.lineTo(0,10);
  158.                   _loc5_.lineTo(0,0);
  159.                   _loc5_.endFill();
  160.                   var _loc3_ = _loc7_.createEmptyMovieClip("_inside",2);
  161.                   _loc3_.beginFill(_loc22_);
  162.                   _loc3_.moveTo(0,0);
  163.                   _loc3_.lineTo(_loc4_ - 20,0);
  164.                   _loc3_.lineTo(_loc4_ - 20,10);
  165.                   _loc3_.lineTo(0,10);
  166.                   _loc3_.lineTo(0,0);
  167.                   _loc3_.endFill();
  168.                   _loc3_._xscale = 0;
  169.                   var _loc6_ = _loc7_.createEmptyMovieClip("_outline",3);
  170.                   _loc6_.lineStyle(0,_loc24_,100);
  171.                   _loc6_.moveTo(0,0);
  172.                   _loc6_.lineTo(_loc4_ - 20,0);
  173.                   _loc6_.lineTo(_loc4_ - 20,10);
  174.                   _loc6_.lineTo(0,10);
  175.                   _loc6_.lineTo(0,0);
  176.                   chk.ad_msec = _loc23_;
  177.                   chk.ad_timeout = _loc26_;
  178.                   chk.started = getTimer();
  179.                   chk.showing = false;
  180.                   chk.last_pcnt = 0;
  181.                   chk.fadeout_time = fadeout_time;
  182.                   chk.fadeFunction = function()
  183.                   {
  184.                      var _loc2_ = 100 * (1 - (getTimer() - this.fadeout_start) / this.fadeout_time);
  185.                      if(_loc2_ > 0)
  186.                      {
  187.                         this._parent._alpha = _loc2_;
  188.                      }
  189.                      else
  190.                      {
  191.                         var _loc3_ = this._parent._parent;
  192.                         MochiAd.unload(_loc3_);
  193.                         delete this.onEnterFrame;
  194.                      }
  195.                   };
  196.                   mc.lc.adLoaded = function(width, height)
  197.                   {
  198.                   };
  199.                   mc.lc.adjustProgress = function(msec)
  200.                   {
  201.                      var _loc2_ = this.mc._mochiad_wait;
  202.                      _loc2_.server_control = true;
  203.                      _loc2_.started = getTimer();
  204.                      _loc2_.ad_msec = msec;
  205.                   };
  206.                   chk.onEnterFrame = function()
  207.                   {
  208.                      var _loc6_ = this._parent._parent;
  209.                      var _loc12_ = this._parent._mochiad_ctr;
  210.                      var _loc5_ = getTimer() - this.started;
  211.                      var _loc3_ = false;
  212.                      var _loc4_ = _loc6_.getBytesTotal();
  213.                      var _loc8_ = _loc6_.getBytesLoaded();
  214.                      var _loc10_ = 100 * _loc8_ / _loc4_;
  215.                      var _loc11_ = 100 * _loc5_ / chk.ad_msec;
  216.                      var _loc9_ = this._mochiad_bar._inside;
  217.                      var _loc2_ = Math.min(100,Math.min(_loc10_ || 0,_loc11_));
  218.                      _loc2_ = Math.max(this.last_pcnt,_loc2_);
  219.                      this.last_pcnt = _loc2_;
  220.                      _loc9_._xscale = _loc2_;
  221.                      if(!chk.showing)
  222.                      {
  223.                         var _loc7_ = _loc12_.getBytesTotal();
  224.                         if(_loc7_ > 0 || typeof _loc7_ == "undefined")
  225.                         {
  226.                            chk.showing = true;
  227.                            chk.started = getTimer();
  228.                         }
  229.                         else if(_loc5_ > chk.ad_timeout)
  230.                         {
  231.                            _loc3_ = true;
  232.                         }
  233.                      }
  234.                      if(_loc5_ > chk.ad_msec)
  235.                      {
  236.                         _loc3_ = true;
  237.                      }
  238.                      if(_loc4_ > 0 && _loc8_ >= _loc4_ && _loc3_)
  239.                      {
  240.                         if(this.server_control)
  241.                         {
  242.                            delete this.onEnterFrame;
  243.                         }
  244.                         else
  245.                         {
  246.                            this.fadeout_start = getTimer();
  247.                            this.onEnterFrame = chk.fadeFunction;
  248.                         }
  249.                      }
  250.                   };
  251.                };
  252.                _global.MochiAd = function()
  253.                {
  254.                }.showInterLevelAd = function(options)
  255.                {
  256.                   var _loc13_ = {clip:_root,ad_timeout:2000,fadeout_time:250,regpt:"o",method:"showTimedAd",ad_started:function()
  257.                   {
  258.                      this.clip.stop();
  259.                   },ad_finished:function()
  260.                   {
  261.                      this.clip.play();
  262.                   }};
  263.                   options = MochiAd._parseOptions(options,_loc13_);
  264.                   var clip = options.clip;
  265.                   var _loc10_ = 11000;
  266.                   var _loc12_ = options.ad_timeout;
  267.                   delete options.ad_timeout;
  268.                   var fadeout_time = options.fadeout_time;
  269.                   delete options.fadeout_time;
  270.                   if(!MochiAd.load(options))
  271.                   {
  272.                      options.ad_finished();
  273.                      return undefined;
  274.                   }
  275.                   options.ad_started();
  276.                   var mc = clip._mochiad;
  277.                   mc.onUnload = function()
  278.                   {
  279.                      options.ad_finished();
  280.                   };
  281.                   var _loc5_ = MochiAd._getRes(options);
  282.                   var _loc14_ = _loc5_[0];
  283.                   var _loc11_ = _loc5_[1];
  284.                   mc._x = _loc14_ * 0.5;
  285.                   mc._y = _loc11_ * 0.5;
  286.                   var chk = mc.createEmptyMovieClip("_mochiad_wait",3);
  287.                   chk.ad_msec = _loc10_;
  288.                   chk.ad_timeout = _loc12_;
  289.                   chk.started = getTimer();
  290.                   chk.showing = false;
  291.                   chk.fadeout_time = fadeout_time;
  292.                   chk.fadeFunction = function()
  293.                   {
  294.                      var _loc2_ = 100 * (1 - (getTimer() - this.fadeout_start) / this.fadeout_time);
  295.                      if(_loc2_ > 0)
  296.                      {
  297.                         this._parent._alpha = _loc2_;
  298.                      }
  299.                      else
  300.                      {
  301.                         var _loc3_ = this._parent._parent;
  302.                         MochiAd.unload(_loc3_);
  303.                         delete this.onEnterFrame;
  304.                      }
  305.                   };
  306.                   mc.lc.adLoaded = function(width, height)
  307.                   {
  308.                   };
  309.                   mc.lc.adjustProgress = function(msec)
  310.                   {
  311.                      var _loc2_ = this.mc._mochiad_wait;
  312.                      _loc2_.server_control = true;
  313.                      _loc2_.started = getTimer();
  314.                      _loc2_.ad_msec = msec - 250;
  315.                   };
  316.                   chk.onEnterFrame = function()
  317.                   {
  318.                      var _loc5_ = this._parent._mochiad_ctr;
  319.                      var _loc4_ = getTimer() - this.started;
  320.                      var _loc2_ = false;
  321.                      if(!chk.showing)
  322.                      {
  323.                         var _loc3_ = _loc5_.getBytesTotal();
  324.                         if(_loc3_ > 0 || typeof _loc3_ == "undefined")
  325.                         {
  326.                            chk.showing = true;
  327.                            chk.started = getTimer();
  328.                         }
  329.                         else if(_loc4_ > chk.ad_timeout)
  330.                         {
  331.                            _loc2_ = true;
  332.                         }
  333.                      }
  334.                      if(_loc4_ > chk.ad_msec)
  335.                      {
  336.                         _loc2_ = true;
  337.                      }
  338.                      if(_loc2_)
  339.                      {
  340.                         if(this.server_control)
  341.                         {
  342.                            delete this.onEnterFrame;
  343.                         }
  344.                         else
  345.                         {
  346.                            this.fadeout_start = getTimer();
  347.                            this.onEnterFrame = this.fadeFunction;
  348.                         }
  349.                      }
  350.                   };
  351.                };
  352.                _global.MochiAd = function()
  353.                {
  354.                }.showTimedAd = function(options)
  355.                {
  356.                   MochiAd.showInterLevelAd(options);
  357.                };
  358.                _global.MochiAd = function()
  359.                {
  360.                }.showPreloaderAd = function(options)
  361.                {
  362.                   MochiAd.showPreGameAd(options);
  363.                };
  364.                _global.MochiAd = function()
  365.                {
  366.                }._allowDomains = function(server)
  367.                {
  368.                   var _loc1_ = server.split("/")[2].split(":")[0];
  369.                   if(System.security)
  370.                   {
  371.                      if(System.security.allowDomain)
  372.                      {
  373.                         System.security.allowDomain("*");
  374.                         System.security.allowDomain(_loc1_);
  375.                      }
  376.                      if(System.security.allowInsecureDomain)
  377.                      {
  378.                         System.security.allowInsecureDomain("*");
  379.                         System.security.allowInsecureDomain(_loc1_);
  380.                      }
  381.                   }
  382.                   return _loc1_;
  383.                };
  384.                _global.MochiAd = function()
  385.                {
  386.                }._loadCommunicator = function(options)
  387.                {
  388.                   var _loc26_ = {clip:_root,com_server:"http://x.mochiads.com/com/1/",method:"loadCommunicator",depth:10337,id:"_UNKNOWN_"};
  389.                   options = MochiAd._parseOptions(options,_loc26_);
  390.                   options.swfv = options.clip.getSWFVersion() || 6;
  391.                   options.mav = MochiAd.getVersion();
  392.                   var _loc18_ = options.clip;
  393.                   var _loc20_ = "_mochiad_com_" + options.id;
  394.                   if(!MochiAd._isNetworkAvailable())
  395.                   {
  396.                      return null;
  397.                   }
  398.                   if(_loc18_[_loc20_])
  399.                   {
  400.                      return _loc18_[_loc20_].lc;
  401.                   }
  402.                   var _loc21_ = options.com_server + options.id;
  403.                   MochiAd._allowDomains(_loc21_);
  404.                   delete options.id;
  405.                   delete options.com_server;
  406.                   var _loc25_ = options.depth;
  407.                   delete options.depth;
  408.                   var _loc17_ = _loc18_.createEmptyMovieClip(_loc20_,_loc25_);
  409.                   var _loc11_ = _loc17_.createEmptyMovieClip("_mochiad_com",1);
  410.                   for(var _loc15_ in options)
  411.                   {
  412.                      _loc11_[_loc15_] = options[_loc15_];
  413.                   }
  414.                   var _loc6_ = new LocalConnection();
  415.                   var _loc16_ = ["",Math.floor(new Date().getTime()),random(999999)].join("_");
  416.                   _loc6_.mc = _loc17_;
  417.                   _loc6_.name = _loc16_;
  418.                   _loc6_.allowDomain = function(d)
  419.                   {
  420.                      return true;
  421.                   };
  422.                   _loc6_.allowInsecureDomain = _loc6_.allowDomain;
  423.                   _loc6_.connect(_loc16_);
  424.                   _loc17_.lc = _loc6_;
  425.                   _loc11_.lc = _loc16_;
  426.                   _loc6_._id = 0;
  427.                   _loc6_._queue = [];
  428.                   _loc6_.rpcResult = function(cb_arg)
  429.                   {
  430.                      var _loc8_ = parseInt(cb_arg);
  431.                      var _loc4_ = this._callbacks[_loc8_];
  432.                      if(!_loc4_)
  433.                      {
  434.                         return undefined;
  435.                      }
  436.                      delete this._callbacks[_loc8_];
  437.                      var _loc5_ = [];
  438.                      var _loc3_ = 2;
  439.                      while(_loc3_ < _loc4_.length)
  440.                      {
  441.                         _loc5_.push(_loc4_[_loc3_]);
  442.                         _loc3_ = _loc3_ + 1;
  443.                      }
  444.                      _loc3_ = 1;
  445.                      while(_loc3_ < arguments.length)
  446.                      {
  447.                         _loc5_.push(arguments[_loc3_]);
  448.                         _loc3_ = _loc3_ + 1;
  449.                      }
  450.                      var _loc6_ = _loc4_[1];
  451.                      var _loc7_ = _loc4_[0];
  452.                      if(_loc7_ && typeof _loc6_ == "string")
  453.                      {
  454.                         _loc6_ = _loc7_[_loc6_];
  455.                      }
  456.                      if(_loc6_)
  457.                      {
  458.                         _loc6_.apply(_loc7_,_loc5_);
  459.                      }
  460.                   };
  461.                   _loc6_._didConnect = function(endpoint)
  462.                   {
  463.                      this._endpoint = endpoint;
  464.                      var _loc4_ = this._queue;
  465.                      delete this._queue;
  466.                      var _loc5_ = this.doSend;
  467.                      var _loc2_ = 0;
  468.                      while(_loc2_ < _loc4_.length)
  469.                      {
  470.                         var _loc3_ = _loc4_[_loc2_];
  471.                         _loc5_.apply(this,_loc3_);
  472.                         _loc2_ = _loc2_ + 1;
  473.                      }
  474.                   };
  475.                   _loc6_.doSend = function(args, cbobj, cbfn)
  476.                   {
  477.                      if(this._endpoint == null)
  478.                      {
  479.                         var _loc4_ = [];
  480.                         var _loc3_ = 0;
  481.                         while(_loc3_ < arguments.length)
  482.                         {
  483.                            _loc4_.push(arguments[_loc3_]);
  484.                            _loc3_ = _loc3_ + 1;
  485.                         }
  486.                         this._queue.push(_loc4_);
  487.                         return undefined;
  488.                      }
  489.                      this._id += 1;
  490.                      var _loc5_ = this._id;
  491.                      if(cbfn === undefined || cbfn === null)
  492.                      {
  493.                         cbfn = cbobj;
  494.                      }
  495.                      this._callbacks[_loc5_] = [cbobj,cbfn];
  496.                      var _loc7_ = new LocalConnection();
  497.                      var _loc9_ = _loc7_.send(this._endpoint,"rpc",_loc5_,args);
  498.                   };
  499.                   _loc6_._callbacks = {};
  500.                   _loc6_._callbacks[0] = [_loc6_,"_didConnect"];
  501.                   _loc11_.st = getTimer();
  502.                   _loc11_.loadMovie(_loc21_ + ".swf","POST");
  503.                   return _loc6_;
  504.                };
  505.                _global.MochiAd = function()
  506.                {
  507.                }.fetchHighScores = function(options, callbackObj, callbackMethod)
  508.                {
  509.                   var _loc1_ = MochiAd._loadCommunicator({id:options.id});
  510.                   if(!_loc1_)
  511.                   {
  512.                      return false;
  513.                   }
  514.                   var _loc4_ = ["fetchHighScores",options];
  515.                   _loc1_.doSend(["fetchHighScores",options],callbackObj,callbackMethod);
  516.                   return true;
  517.                };
  518.                _global.MochiAd = function()
  519.                {
  520.                }.sendHighScore = function(options, callbackObj, callbackMethod)
  521.                {
  522.                   var _loc1_ = MochiAd._loadCommunicator({id:options.id});
  523.                   if(!_loc1_)
  524.                   {
  525.                      return false;
  526.                   }
  527.                   var _loc4_ = ["sendHighScore",options];
  528.                   _loc1_.doSend(["sendHighScore",options],callbackObj,callbackMethod);
  529.                   return true;
  530.                };
  531.                _global.MochiAd = function()
  532.                {
  533.                }.load = function(options)
  534.                {
  535.                   var _loc13_ = {clip:_root,server:"http://x.mochiads.com/srv/1/",method:"load",depth:10333,id:"_UNKNOWN_"};
  536.                   options = MochiAd._parseOptions(options,_loc13_);
  537.                   options.swfv = options.clip.getSWFVersion() || 6;
  538.                   options.mav = MochiAd.getVersion();
  539.                   var _loc9_ = options.clip;
  540.                   if(!MochiAd._isNetworkAvailable())
  541.                   {
  542.                      return null;
  543.                   }
  544.                   if(_loc9_._mochiad_loaded)
  545.                   {
  546.                      return null;
  547.                   }
  548.                   var _loc12_ = options.depth;
  549.                   delete options.depth;
  550.                   var _loc6_ = _loc9_.createEmptyMovieClip("_mochiad",_loc12_);
  551.                   var _loc11_ = MochiAd._getRes(options);
  552.                   options.res = _loc11_[0] + "x" + _loc11_[1];
  553.                   options.server += options.id;
  554.                   delete options.id;
  555.                   _loc9_._mochiad_loaded = true;
  556.                   var _loc4_ = _loc6_.createEmptyMovieClip("_mochiad_ctr",1);
  557.                   for(var _loc7_ in options)
  558.                   {
  559.                      _loc4_[_loc7_] = options[_loc7_];
  560.                   }
  561.                   var _loc10_ = _loc4_.server;
  562.                   delete _loc4_.server;
  563.                   var _loc14_ = MochiAd._allowDomains(_loc10_);
  564.                   _loc6_.onEnterFrame = function()
  565.                   {
  566.                      if(this._mochiad_ctr._url != this._url)
  567.                      {
  568.                         this.onEnterFrame = function()
  569.                         {
  570.                            if(!this._mochiad_ctr)
  571.                            {
  572.                               delete this.onEnterFrame;
  573.                               MochiAd.unload(this._parent);
  574.                            }
  575.                         };
  576.                      }
  577.                   };
  578.                   var _loc5_ = new LocalConnection();
  579.                   var _loc8_ = ["",Math.floor(new Date().getTime()),random(999999)].join("_");
  580.                   _loc5_.mc = _loc6_;
  581.                   _loc5_.name = _loc8_;
  582.                   _loc5_.hostname = _loc14_;
  583.                   _loc5_.allowDomain = function(d)
  584.                   {
  585.                      return true;
  586.                   };
  587.                   _loc5_.allowInsecureDomain = _loc5_.allowDomain;
  588.                   _loc5_.connect(_loc8_);
  589.                   _loc6_.lc = _loc5_;
  590.                   _loc4_.lc = _loc8_;
  591.                   _loc4_.st = getTimer();
  592.                   _loc4_.loadMovie(_loc10_ + ".swf","POST");
  593.                   return _loc6_;
  594.                };
  595.                _global.MochiAd = function()
  596.                {
  597.                }.unload = function(clip)
  598.                {
  599.                   if(typeof clip == "undefined")
  600.                   {
  601.                      clip = _root;
  602.                   }
  603.                   if(clip.clip && clip.clip._mochiad)
  604.                   {
  605.                      clip = clip.clip;
  606.                   }
  607.                   if(!clip._mochiad)
  608.                   {
  609.                      return false;
  610.                   }
  611.                   clip._mochiad.removeMovieClip();
  612.                   delete clip._mochiad_loaded;
  613.                   delete clip._mochiad;
  614.                   return true;
  615.                };
  616.                _global.MochiAd = function()
  617.                {
  618.                }._isNetworkAvailable = function()
  619.                {
  620.                   if(System.security)
  621.                   {
  622.                      var _loc1_ = System.security;
  623.                      if(_loc1_.sandboxType == "localWithFile")
  624.                      {
  625.                         return false;
  626.                      }
  627.                   }
  628.                   return true;
  629.                };
  630.                _global.MochiAd = function()
  631.                {
  632.                }._getRes = function(options)
  633.                {
  634.                   var _loc3_ = options.clip.getBounds();
  635.                   var _loc2_ = 0;
  636.                   var _loc1_ = 0;
  637.                   if(typeof options.res != "undefined")
  638.                   {
  639.                      var _loc4_ = options.res.split("x");
  640.                      _loc2_ = parseFloat(_loc4_[0]);
  641.                      _loc1_ = parseFloat(_loc4_[1]);
  642.                   }
  643.                   else
  644.                   {
  645.                      _loc2_ = _loc3_.xMax - _loc3_.xMin;
  646.                      _loc1_ = _loc3_.yMax - _loc3_.yMin;
  647.                   }
  648.                   if(_loc2_ == 0 || _loc1_ == 0)
  649.                   {
  650.                      _loc2_ = Stage.width;
  651.                      _loc1_ = Stage.height;
  652.                   }
  653.                   return [_loc2_,_loc1_];
  654.                };
  655.                _global.MochiAd = function()
  656.                {
  657.                }._parseOptions = function(options, defaults)
  658.                {
  659.                   var _loc4_ = {};
  660.                   for(var _loc8_ in defaults)
  661.                   {
  662.                      _loc4_[_loc8_] = defaults[_loc8_];
  663.                   }
  664.                   if(options)
  665.                   {
  666.                      for(_loc8_ in options)
  667.                      {
  668.                         _loc4_[_loc8_] = options[_loc8_];
  669.                      }
  670.                   }
  671.                   if(_root.mochiad_options)
  672.                   {
  673.                      var _loc5_ = _root.mochiad_options.split("&");
  674.                      var _loc2_ = 0;
  675.                      while(_loc2_ < _loc5_.length)
  676.                      {
  677.                         var _loc3_ = _loc5_[_loc2_].split("=");
  678.                         _loc4_[unescape(_loc3_[0])] = unescape(_loc3_[1]);
  679.                         _loc2_ = _loc2_ + 1;
  680.                      }
  681.                   }
  682.                   if(_loc4_.id == "test")
  683.                   {
  684.                      trace("[MochiAd] WARNING: Using the MochiAds test identifier, make sure to use the code from your dashboard, not this example!");
  685.                   }
  686.                   return _loc4_;
  687.                };
  688.                ┬º┬ºpush(ASSetPropFlags(_global.MochiAd.prototype,null,1));
  689.             }
  690.             ┬º┬ºpop();
  691.             break;
  692.          }
  693.          if(eval("\x01") == 970)
  694.          {
  695.             set("\x01",eval("\x01") + 1);
  696.             if(function ┬º\x04\x05┬º()
  697.             {
  698.                set("\x03",2791 % 511 * 5);
  699.                return eval("\x03");
  700.             })
  701.             {
  702.                set("\x01",eval("\x01") - 139);
  703.             }
  704.          }
  705.          else if(eval("\x01") == 445)
  706.          {
  707.             set("\x01",eval("\x01") + 317);
  708.             if(function ┬º\x04\x05┬º()
  709.             {
  710.                set("\x03",2791 % 511 * 5);
  711.                return eval("\x03");
  712.             })
  713.             {
  714.                set("\x01",eval("\x01") + 2);
  715.             }
  716.          }
  717.          else if(eval("\x01") == 845)
  718.          {
  719.             set("\x01",eval("\x01") - 20);
  720.          }
  721.          else
  722.          {
  723.             if(eval("\x01") == 971)
  724.             {
  725.                set("\x01",eval("\x01") - 139);
  726.                stop();
  727.                break;
  728.             }
  729.             if(eval("\x01") == 764)
  730.             {
  731.                set("\x01",eval("\x01") + 61);
  732.             }
  733.             else if(eval("\x01") == 164)
  734.             {
  735.                set("\x01",eval("\x01") + 407);
  736.                ┬º┬ºpush(!function ┬º\x04\x05┬º()
  737.                {
  738.                   set("\x03",2791 % 511 * 5);
  739.                   return eval("\x03");
  740.                });
  741.             }
  742.             else if(eval("\x01") == 621)
  743.             {
  744.                set("\x01",eval("\x01") - 405);
  745.                ┬º┬ºpush(true);
  746.             }
  747.             else
  748.             {
  749.                if(eval("\x01") == 848)
  750.                {
  751.                   set("\x01",eval("\x01") - 848);
  752.                   break;
  753.                }
  754.                if(eval("\x01") == 805)
  755.                {
  756.                   set("\x01",eval("\x01") - 641);
  757.                   ┬º┬ºpush(eval(function ┬º\x04\x05┬º()
  758.                   {
  759.                      set("\x03",2791 % 511 * 5);
  760.                      return eval("\x03");
  761.                   }));
  762.                }
  763.                else if(eval("\x01") == 344)
  764.                {
  765.                   set("\x01",eval("\x01") + 101);
  766.                   ┬º┬ºpush(true);
  767.                }
  768.                else if(eval("\x01") == 703)
  769.                {
  770.                   set("\x01",eval("\x01") + 102);
  771.                   ┬º┬ºpush("\x0f");
  772.                }
  773.                else if(eval("\x01") == 601)
  774.                {
  775.                   set("\x01",eval("\x01") - 574);
  776.                   ┬º┬ºpush("\x0f");
  777.                   ┬º┬ºpush(1);
  778.                }
  779.                else
  780.                {
  781.                   if(eval("\x01") == 762)
  782.                   {
  783.                      set("\x01",eval("\x01") + 2);
  784.                      play();
  785.                      if(!function ┬º\x04\x05┬º()
  786.                      {
  787.                         set("\x03",2791 % 511 * 5);
  788.                         return eval("\x03");
  789.                      } || _loc6_ < eval(┬º┬ºconstant(136))[┬º┬ºconstant(296)](_loc2_))
  790.                      {
  791.                         var _loc6_ = _loc2_;
  792.                         var _loc5_ = _loc7_ / 4;
  793.                      }
  794.                      else
  795.                      {
  796.                         _loc5_ = _loc7_ / 6.283185307179586 * eval(┬º┬ºconstant(136))[┬º┬ºconstant(297)](_loc2_ / _loc6_);
  797.                      }
  798.                      var _loc1_ = null;
  799.                      return - _loc6_ * eval(┬º┬ºconstant(136))[┬º┬ºconstant(292)](2,10 * (_loc1_ = (_global.MochiAd = function()
  800.                      {
  801.                      }) - 1)) * eval(┬º┬ºconstant(136))[┬º┬ºconstant(289)]((_loc1_ * _loc3_ - _loc5_) * 6.283185307179586 / _loc7_) + _loc4_;
  802.                   }
  803.                   if(eval("\x01") == 571)
  804.                   {
  805.                      set("\x01",eval("\x01") + 257);
  806.                      if(function ┬º\x04\x05┬º()
  807.                      {
  808.                         set("\x03",2791 % 511 * 5);
  809.                         return eval("\x03");
  810.                      })
  811.                      {
  812.                         set("\x01",eval("\x01") - 481);
  813.                      }
  814.                   }
  815.                   else
  816.                   {
  817.                      if(eval("\x01") == 206)
  818.                      {
  819.                         set("\x01",eval("\x01") + 776);
  820.                         break;
  821.                      }
  822.                      if(eval("\x01") == 355)
  823.                      {
  824.                         set("\x01",eval("\x01") + 266);
  825.                      }
  826.                      else
  827.                      {
  828.                         if(eval("\x01") != 485)
  829.                         {
  830.                            break;
  831.                         }
  832.                         set("\x01",eval("\x01") + 136);
  833.                      }
  834.                   }
  835.                }
  836.             }
  837.          }
  838.       }
  839.    }
  840. }
  841.